intro-GEE-y-JS.knit

class: inverse,left, middle
background-image: url(data:image/png;base64,#background.png)
background-size: cover

##Módulo 4: Procesameinto masivo de datos geoespaciales

### Introducción a Google Earth Engine y JavaScript

Gabriel Castro 
gabriel.castro.b@pucv.cl</a>

.large[<a href="https://www.pucv.cl/uuaa/site/edic/base/port/labgrs.html">LabGRS</a> | Noviembre 2022]

---
class: center,middle
background-image: url(data:image/png;base64,#labgrs_logo.png)
background-size: 35%

---
## Contenidos

--
1) ¿Que es Google Earth Engine? (GEE).

2) Introducción a JavaScript.

--
<center>
<img src="data:image/png;base64,#GEE.jpg" width="1200px" HEIGHT = "400px"/>
<center>

---
### ¿Que es Google earth engine?

> Google Earth Engine (GEE) es una plataforma basada en la nube para el análisis geoespacial a escala planetaria que ofrece las capacidades computacionales masivas de Google permitiendo abordar una variedad de problemas sociales de alto impacto, incluyendo deforestación, sequía, desastres, enfermedades, seguridad alimentaria, gestión del agua, monitoreo del clima y protección del medio ambiente (Gorelick et al., 2017).
>

<center>
![](data:image/png;base64,#cloud_computing.png)
<center>

<center>
![](data:image/png;base64,#logo_engine.jpg)
<center>

---
### Cloud computing

> La computación en la nube (cloud computing) es la última revolución de la tecnología de información.
>
> Servidores dedicados al procesamiento masivo.
> 
> Mejora en el flujo y tiempo de trabajo de forma excepcional.

--
<center>
<img src="data:image/png;base64,#servidores.jpg" width="1200px" HEIGHT = "400px"/>
<center>

---
### ¿Como funciona la API?

> Google earth engine utiliza JavaScript como lenguaje de programación base. Sin embargo, podemos encontrar otras fuentes y plataformas diponibles. 
>

---
### Catálogo disponible.

---
### Ventajas y desventajas de GEE:
.pull-left[
* **Ventajas:**
    + Capacidades computacionales de alta capacidad. 
    + Rapidez para realizar procesos complejos.
    + Amplios catálogos de información disponibles.
    + Amigable con el usuario basico (gran cantidad de manuales y código a disposición)
]

.pull-right[
* **Desventajas:**
    +  Requiere habilidades programaticas de JS para elaborar procesos mas complejos.
    +  Capacidad almacenamiento es limitada (almacenamiento Drive).
    +  Actualmente es gratuito, esto puede cambiar en el futuro.
    +  No es funcional para procesos dependientes del entorno (ejemplo: análisis de redes, drenaje, etc.)
]

---
> **Code Editor:** nos dirige a la consola de engine para comenzar a trabajar.
>
> **Documentation:** nos dirige a la pagina de GEE donde podemos encontrar una serie de manuales para el procesamiento de informacion satelital.

<center>
<img src="data:image/png;base64,#pantallazo.jpg" width="1200px" HEIGHT = "500px"/>
<center>
---
### Code Editor:
<center>
<img src="data:image/png;base64,#codeeditor.jpg" width="1200px" HEIGHT = "600px"/>
<center>

---
### Documentation:

---
### Tipos de objetos:

> **Strings:** Variables de texto o cadenas de caracteres, se utilizan las comillas simples o dobles para definir una cadena.

```java
// Usamos comillas simples o dobles para crear un string
var saludoString = 'Hola Mundo!!';
print( saludoString );
```
> **Numeros:** En las variables tambien podemos almacenar números de distinta longitud y precisión.

```java
// Asignamos un número a una variable
var numero = 38;
print('El valor es:', numero);
```
> **Listas:** Las listas las definimos con corchetes [ ]. En GEE son útiles para realizar selecciones de elementos y podemos almacenar números, caracteres u otros elementos.

```java
// Lista de números
var listDeNumeros = [0, 1, 1, 2, 3, 5];
print('Lista de Números:', listDeNumeros);
// Lista de strings.
var listDeStrings = ['a', 'b', 'c', 'd'];
print('Lista de strings:', listDeStrings);
```

---
> **Objetos (Diccionarios):**

>Los objetos en JS hace mención a una estructura que puede contener otros valores definidos por {}. Se utilizan claves para nombrar las variables contenidas en su interior las cuales pueden ser llamadas del forma individual o completa.

```java
// Usamos las llaves {} para hacer un diccionario de pares clave:valor
var object = {
  foo: 'bar',
  baz: 38,
  stuff: ['Algo', 'eso', 'otro más']
};
print('Diccionario:', object);
// Para acceder al valor de un diccionario se utiliza la clave y los corchetes [ ].
print('Imprime la clave foo:', object['foo']);
// También se puede acceder utilizando la notación con punto.
print('Print stuff:', object.stuff);
```

* Los objetos o diccionarios a diferencia de las listas, son objetos mas complejos dentro de Engine que permiten almacenar distintos tipos de variables en su interior

--
* En cuanto a su funcionalidad, los diccionarios cumplen el mismo proposito que los objetos, la diferencia esta en la creación de un contenedor .ee

---

> **Funciones:**  Las funciones son otra forma de mejorar la legibilidad y reutilización del código mediante el agrupamiento de operaciones.

>    +  Una función se define mediante _function()_ en nuestro script.
>    +  Los nombres de las funciones comienzan con una letra y tienen un par de paréntesis al final.
>    +  Las funciones a menudo toman parámetros pra definir su objetivo. Estos parámetros van dentro de los                     paréntesis ().
>    +  El conjunto de declaraciones que componen la función van dentro de las llaves { }. finalmente, return indica            cuáles la salida de la función.

```java
// Ejemplo de cómo se define una función
var funcion_saludo = function( nombre ) {
  var mensaje = '¡Hola ' + nombre + '! ¿Que hora es?';
  return mensaje;
};
// llamamos a la función con su parámetro.
print( funcion_saludo( 'Gabriel' ) );
```

---
### Contenedores de GEE.

* Google earth engine posee contenedores especificos dentro de la API (.ee) los cuales permiten enviar dicha información para ser procesada en los servidores de la nube.
* Strings: Para definir un string, tenemos que agregarlo al contenedor ee.String() y el contenedor será enviado a GEE.

```java
// Definimos un string y lo agregamos al contenedor
var unString = 'procesando';
var eeString = ee.String(unString);
print('Donde estabas? ', eeString);

// 
```
* Trabajar con contenedroes de engine asegura la optimización del trabajo y la velocidad del mismo. No uilizar los contenedores en nuestras variables puede deribar en los "cuellos de botella" los cuales relentizan el procesamiento.

---
> **Números:** 
>
> Utilice ee.Number() para crear un objeto número en el servidor. Por ejemplo, utilice el método JavaScript Math.E para crear un valor de la constante en el servidor:

```java
// Definimos un número en el servidor
var serverNumber = ee.Number(Math.E);
print('e = ', serverNumber);
```
>Los métodos ee.String() y ee.Number() son constructores, y por tanto, tienen argumentos (y posiblemente otros parámetros). Un constructor comienza siempre con ee y retorna un objeto EE.

---
### Métodos en un objeto EE
Para operar con un objeto de EE vamos a utilizar los métodos que son provistos según la clase de objeto con la que pretendemos trabajar. Existen multiples metodos para operar dentro de GEE.

```java
// Utilice una función incorporada para realizar una operación en el número.
var logE = serverNumber.log();
print('log(e) = ', logE);
```
Listas: Podemos hacer una lista de JavaScript como un objeto ee.List en el servidor, ponemos un literal de JavaScript en un contenedor con números y cadenas.

```java
// Ejemplos de listas, secuencia por extensión
var eeList = ee.List([1, 2, 3, 4, 5]);
// Secuencia usando el método del objeto list
var secuencia = ee.List.sequence(1, 5);
print('Secuencia:', secuencia);
```
---
Podemos recuperar un elemento de la lista con el operador get(). Recuerde que esta lista solo existe en el servidor, EE nos permite acceder a esos objetos solo a través de sus métodos.

```java
// Usamos un método de ee.List para recuperar un valor
var valor = secuencia.get(2);
print('Valor en la posición 2:', valor);
```
Diccionarios: Podemos crear un diccionario en Earth Engine a partir de un objeto JavaScript, de la misma manera que lo hicimos con String, Number y List. La función ee.Dictionary se construye desde un objeto JavaScript.

```java
// Crear un diccionario en el servidor
var diccionario = ee.Dictionary({
  e: Math.E,
  pi: Math.PI,
  phi: (1 + Math.sqrt(5)) / 2
});
// Recuperar algunos valores desde el diccionario.
print('Euler:', diccionario.get('e'));
print('Pi:', diccionario.get('pi'));
print('Golden ratio:', diccionario.get('phi'));
// Recuperar todas las claves
print('Claves: ', diccionario.keys());
```

---

Fechas: Los objetos de tipo ee.Date nos permiten representar tiempo.

Al igual que con los otros tipos de datos, NO se debe  confundir entre Date de JavaScript y el ee.Date de EE.

```java
// Definir una fecha en Earth Engine.
var fecha = ee.Date('2015-12-31');
print('Fecha:', fecha);
// Recuperar la fecha actual usando el método Date.now() de JavaScript.
var now = Date.now();
print('Milisegundos desde el 1 de Enero de 1970', now);
// Inicializar el objeto ee.Date
var eeNow = ee.Date(now);
print('Now:', eeNow);
```

* Los objetos fechas son muy importantes para filtrar las colecciones, utilizando la función filterDate().

---
* Recordatorios:

>Cada vez que se desee declarar una variable se debe iniciar con la palabra var y para finalizar la 
 lógica de una línea de código se debe finalizar con ;

> Normalmente los ( ) hacen referencia a una función, sin embargo, también sirven para conformar un 
 conjunto lógicos. Los [ ] sirven para construir arreglos o listas. Los { } normalmente sirven para 
 formas objetos; entiéndase como un objetico a los parámetros o opciones que se le pueden dar a un 
 gráfico, algoritmo o alguna función en específico. 
 
> Es una buena práctica poner muchos comentarios en tu código, para describir lo que estás tratando 
 de hacer. También es bueno eliminar el código comentado que ya no hace nada. Ambas prácticas 
 mejorarán la legibilidad del código.

> Los objetos y algoritmos implícitos en GEE a diferencia del lenguaje común de JavaScript se 
 caracterizan principalmente por usar al inicio .ee
 Todos los elementos que se remarcan en color violeta, hacen referencia a una función implícitas de 
 GEE. Los elementos remarcados en color verde hacen referencia a comentarios. Las líneas de 
 códigos remarcadas en color rojo hacen referencia a conjuntos de valores descritos dentro de un 
 metadato. Asimismo, sirven para asignar nombres, colores y configuraciones o parámetros de algunas 
 funciones o algoritmos. Los elementos que se muestran en color azul, hacen referencia a valores 
 numéricos.
---
 
### Bibliografía.

GORELICK, N., HANCHER, M., DIXON, M., ILYUSHCHENKO, S., THAU, D. y MOORE, R., 2017. Google Earth Engine: Planetary-scale geospatial analysis for everyone. Remote Sensing of Environment [en línea], vol. 202, pp. 18-27. ISSN 00344257. DOI 10.1016/j.rse.2017.06.031. Disponible en: https://doi.org/10.1016/j.rse.2017.06.031.

REDD, P.R.R. de E. por D. y D. de B. en C. y R.D., 2018. Introducción a Javascript para Google Earth Engine (GEE). Deutsche Gesellschaft für Internationale Zusammenarbeit (GIZ) [en línea], vol. 1. Disponible en: https://www.sica.int/download/?124837.

Google Earth Engine. (s. f.). https://earthengine.google.com/

Pérez, J. E. (2008). introducción JavaScript. Madrid, España.

---
class: inverse middle
![logo](data:image/png;base64,#LABGRS-PUCV.png)